package main

import "fmt"

type TreeNode struct {
	left, right *TreeNode
	val int
}

// 中序遍历
func (node *TreeNode) TraverseFunc(f func(*TreeNode)){  // 传递一个函数
	if node == nil {
		return 
	}

	node.left.TraverseFunc(f)
	f(node)
	node.right.TraverseFunc(f)
}



// 给结构体定义方法
func (node *TreeNode) print() {  // (node TreeNode) 接收者
	fmt.Println(node.val)
}

func (node *TreeNode) setValue(val int) {
	if node == nil {
		fmt.Println("Setting val to nil node!")
		return
	}
	node.val = val
}

// 工厂函数
func createNode(val int) *TreeNode{
	return &TreeNode{val: val}
}


// 定义自己的节点
type MyTreeNode struct {
	node *tree.Node // 保存节点类型的指针。（根据go语言习惯，包名叫tree， 将TreeNode 改写为 Node）
}

func (myNode *MyTreeNode) inOrder() {
	fmt.Println("实现自己的中序遍历")
}

type Node struct {
	Val int
	Left *TreeNode
	Right *TreeNode
}

func main() {
	// 定义
	var root1 TreeNode
	root2 := TreeNode{}

	// 初始化
	root1 = TreeNode{val: 3}

	root1.left = &root2  // 注意 指针，传递地址
	root1.right = &TreeNode{val: 4}

	fmt.Println(root1.val)

	nodes := []TreeNode {
		// 省略掉 初始化数据
		{val: 3},
		{},
		{nil, &root1, 6},
	}

	fmt.Println(nodes)

	root1.left.right = createNode(9)

	root1.print()

	var pRoot *TreeNode
	pRoot.setValue(200)
	pRoot = &root1
	pRoot.setValue(300)
	pRoot.print()

	zxc := []int{}
	var cvb []int
	fmt.Println(zxc == nil, cvb == nil)

	nodeCnt := 0
	root1.TraverseFunc(func (node * TreeNode){
		nodeCnt ++
	})
	fmt.Println(nodeCnt)
}

